// 班级控制器
const { Class, User } = require('../models');

/**
 * 班级控制器
 * 处理班级相关的业务逻辑
 */
class ClassController {
  /**
   * 获取所有班级列表（支持分页）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getAllClasses(req, res) {
    try {
      // 获取分页参数
      const { page = 1, pageSize = 10 } = req.query;
      const pageNum = parseInt(page) || 1;
      const size = parseInt(pageSize) || 10;
      const offset = (pageNum - 1) * size;
      
      // 查询总数
      const total = await Class.count();
      
      // 查询班级列表
      const classes = await Class.findAll({
        order: [['grade', 'DESC'], ['className', 'ASC']],
        limit: size,
        offset: offset
      });

      // 为每个班级统计学生人数
      const classesWithStudentCount = await Promise.all(
        classes.map(async (cls) => {
          // 统计该班级的学生人数（只统计role为student的用户）
          const studentCount = await User.count({
            where: {
              classId: cls.id,
              role: 'student'
            }
          });
          
          return {
            ...cls.toJSON(),
            student_count: studentCount
          };
        })
      );

      res.json({
        success: true,
        data: {
          classes: classesWithStudentCount,
          total: total,
          page: pageNum,
          pageSize: size,
          totalPages: Math.ceil(total / size)
        }
      });
    } catch (error) {
      console.error('获取班级列表失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 获取单个班级信息
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getClassById(req, res) {
    try {
      const { classId } = req.params;

      const cls = await Class.findByPk(classId);
      if (!cls) {
        return res.status(404).json({
          success: false,
          message: '班级不存在'
        });
      }

      res.json({
        success: true,
        data: cls
      });
    } catch (error) {
      console.error('获取班级信息失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 创建班级
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async createClass(req, res) {
    try {
      const { className, grade } = req.body;

      // 验证输入
      if (!className || !grade) {
        return res.status(400).json({
          success: false,
          message: '请输入班级名称和年级'
        });
      }

      // 检查班级是否已存在
      const existingClass = await Class.findOne({
        where: { className }
      });

      if (existingClass) {
        return res.status(400).json({
          success: false,
          message: '班级已存在'
        });
      }

      // 创建班级
      const cls = await Class.create({
        className,
        grade
      });

      res.json({
        success: true,
        message: '班级创建成功',
        data: cls
      });
    } catch (error) {
      console.error('创建班级失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 更新班级信息
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async updateClass(req, res) {
    try {
      const { classId } = req.params;
      const { className, grade } = req.body;

      // 查找班级
      const cls = await Class.findByPk(classId);
      if (!cls) {
        return res.status(404).json({
          success: false,
          message: '班级不存在'
        });
      }

      // 如果要修改班级名称，检查是否已存在
      if (className && className !== cls.className) {
        const existingClass = await Class.findOne({
          where: { className }
        });

        if (existingClass) {
          return res.status(400).json({
            success: false,
            message: '班级名称已存在'
          });
        }
      }

      // 更新班级信息
      await cls.update({
        className: className || cls.className,
        grade: grade || cls.grade
      });

      res.json({
        success: true,
        message: '班级信息更新成功',
        data: cls
      });
    } catch (error) {
      console.error('更新班级信息失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 删除班级
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async deleteClass(req, res) {
    try {
      const { classId } = req.params;

      // 查找班级
      const cls = await Class.findByPk(classId);
      if (!cls) {
        return res.status(404).json({
          success: false,
          message: '班级不存在'
        });
      }

      // 删除班级
      await cls.destroy();

      res.json({
        success: true,
        message: '班级删除成功'
      });
    } catch (error) {
      console.error('删除班级失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }
}

module.exports = ClassController;